/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package srac.controleeventos.cci;

import java.net.MalformedURLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.commons.mail.EmailException;
import org.zkoss.zk.ui.Component;
import org.zkoss.zk.ui.Executions;
import org.zkoss.zul.Window;
import srac.controleatividades.cdp.Aluno;
import srac.controleatividades.cdp.Usuario;
import srac.controleeventos.cdp.Evento;
import srac.controleeventos.cdp.Participante;
import srac.controleeventos.cdp.TipoEvento;
import srac.controleeventos.cgt.AplControleEvento;
import srac.controleeventos.cgt.AplEnviarCertificado;
import srac.controleeventos.cih.PagEventosConfirmarPresenca;
import srac.controleeventos.cih.PagEventosEvento;
import srac.controleeventos.cih.PagEventosInscricao;
import util.utilitarioEndereco.cdp.Bairro;
import util.utilitarioEndereco.cdp.Estado;
import util.utilitarioEndereco.cdp.Municipio;
import util.utilitarioEndereco.cdp.Pais;
import util.utilitarioExceptions.SracException;

/**
 *
 * @author Administrador
 */
public class CtrlEvento {

    public static final int SALVAR = 0;
    public static final int EDITAR = 1;
    public static final int CONSULTAR = 2;
    private Window window;
    private PagEventosConfirmarPresenca pagEventoConfirmarPresenca;
    private PagEventosInscricao pagEventosInscricao;
    private PagEventosEvento pagEventosEvento;
    private AplControleEvento apl = AplControleEvento.getInstance();

    public static CtrlEvento getInstance() {
        CtrlEvento instance = (CtrlEvento) Executions.getCurrent().getSession().getAttribute("ctrlEvento");
        if (instance == null) {
            instance = new CtrlEvento();
            Executions.getCurrent().getSession().setAttribute("ctrlEvento", instance);
        }
        return instance;
    }
    
    public void setPagEventosEvento(PagEventosEvento pagEventosEvento) {
        this.pagEventosEvento = pagEventosEvento;
    }
    
    public void setPagEventosInscricao(PagEventosInscricao pagEventosInscricao) {
        this.pagEventosInscricao = pagEventosInscricao;
    }
    
    public void setPagEventoConfirmarPresenca(PagEventosConfirmarPresenca pagEventoConfirmarPresenca) {
        this.pagEventoConfirmarPresenca = pagEventoConfirmarPresenca;
    }
       
    public void abrirInscricaoEvento(Evento evento) {
        Map map = new HashMap();
        map.put("obj", evento);
        Executions.createComponents("/PagFormularioInscricao.zul", null, map);
    }
      
    private CtrlEvento() {
    }


    public Evento incluirEvento(ArrayList<Object> args) {
        Evento e = null;
        try {
            e = apl.incluirEvento(args);
            if (e != null) {
                pagEventosEvento.addEvento(e);
                pagEventosEvento.setMensagemAviso("success", "Cadastro feito com sucesso");
            }
        } catch (Exception ex) {
            pagEventosEvento.setMensagemAviso("error", "Erro ao cadastrar o evento");
            System.err.println(ex.getMessage());
        }
        return e;
    }

    public Evento alterarEvento(Evento evento) {
        Evento e = null;
        try {
            e = apl.alterarEvento(evento);
            if (pagEventosEvento != null) {
                pagEventosEvento.refreshEvento(e);
                pagEventosEvento.setMensagemAviso("success", "Cadastro editado com sucesso");
            }
        } catch (Exception ex) {
            pagEventosEvento.setMensagemAviso("error", "Erro ao cadastrar o evento");
            System.err.println(ex.getMessage());
        }
        return e;
    }
    
    public void incluirParticipante(Participante participante) {
        try {
            Participante p = (Participante) apl.incluirParticipante(participante);
            if (p != null) {
                pagEventosInscricao.refreshEvento(p.getEvento());
                pagEventosInscricao.setMensagemAviso("success", "Inscrição realizada com sucesso");
            }
        } catch (Exception ex) {
            pagEventosInscricao.setMensagemAviso("error", "Erro ao realizar a inscrição no evento");
            System.err.println(ex.getMessage());
        }
    }

    public Boolean apagarEvento(Evento evento) throws Exception {
        return apl.excluirEvento(evento);
    }

    public List<Evento> obterEvento() throws Exception {
        return apl.obterEvento();
    }
    
    /**
     * Obtém uma lista com todas as Municipio a partir de um Estado
     * <p/>
     * @return
     */
    public List<Municipio> obterMunicipio(Estado estado) {
        try {
            return apl.obterMunicipio(estado);
        }
        catch (Exception ex) {
            Logger.getLogger(CtrlEvento.class.getName()).log(Level.SEVERE, null, ex);
        }
        return null;
    }
    
     /**
     * Obtém uma lista com todas as Estados a partir de um país
     * <p/>
     * @return
     */
    public List<Estado> obterEstados(Pais pais) {
        try {
            return apl.obterEstados(pais);
        }
        catch (Exception ex) {
            Logger.getLogger(CtrlEvento.class.getName()).log(Level.SEVERE, null, ex);
        }

        return null;
    }
    
    /**
     * Obtém uma lista de todos os Paises cadastrados
     * <p/>
     * @return
     */
    public List<Pais> obterPaises() throws SracException, Exception {
        return apl.obterPais();
    }
    
    /**
     * Obtém uma lista com todas as Bairro a partir de um Municipio
     * <p/>
     * @return
     */
    public List<Bairro> obterBairro(Municipio municipio) {
        try {
            return apl.obterBairro(municipio);
        }
        catch (Exception ex) {
            Logger.getLogger(CtrlEvento.class.getName()).log(Level.SEVERE, null, ex);
        }
        return null;
    }

    public void abrirIncluirEvento() {
        Map map = new HashMap();
        map.put("tipo", CtrlEvento.SALVAR);
        Executions.createComponents("/PagFormularioEventos.zul", null, map);
    }

    public Component abrirEditarEvento(Evento evento) {
        Map map = new HashMap();
        map.put("tipo", CtrlEvento.EDITAR);
        map.put("obj", evento);
        return Executions.createComponents("/PagFormularioEventos.zul", null, map);
    }
    
    public void abrirConsultarEvento(Evento evento) {
        Map map = new HashMap();
        map.put("tipo", CtrlEvento.CONSULTAR);
        map.put("obj", evento);
        Executions.createComponents("/PagFormularioEventos.zul", null, map);
    }

     public Component abrirEventosEvento() {
        return Executions.createComponents("/PagEventosEvento.zul", null, null);
    }
    
    public void redirectPag(String url) {
        Executions.sendRedirect(url);
    }

    public List<Participante> obterParticipanteEvento(Evento select) {
        return apl.obterEventoParticipante(select);
    }

    public List<Evento> obterEventoAberto() {
        return apl.obterEventoAberto();
    }
    

    public void inscreverAlunoEvento(Usuario u, Evento e) {
        try {
            if(apl.inscreverAlunoEvento(u,e))
            {
                pagEventosInscricao.refreshEvento(e);
                pagEventosInscricao.setMensagemAviso("success", "Inscrição realizada com sucesso");
            }
            else
            {
                pagEventosInscricao.setMensagemAviso("info", "Você já está inscrito neste evento!");
            }
        } catch (Exception ex) {
            pagEventosInscricao.setMensagemAviso("error", "Erro ao realizar a inscrição no evento");
            ex.printStackTrace();
        }
    }



    public void aterarPresenca(List<Participante> participantes, boolean b) {
        try {
            apl.aterarPresenca(participantes,b);
        } catch (Exception ex) {
            Logger.getLogger(CtrlEvento.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void emitirCertificado(List<Participante> participantes) {
        try {
            apl.emitirCertificado(participantes);
            pagEventoConfirmarPresenca.setMensagemAviso("success", "Certificados enviados com sucesso!");
        } catch (Exception ex) {
            pagEventoConfirmarPresenca.setMensagemAviso("error", "Erro ao enviar os certificados!");
            Logger.getLogger(CtrlEvento.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void encerrarEvento(Evento e) {
        try {
            apl.encerrarEvento(e);
        } catch (Exception ex) {
            Logger.getLogger(CtrlEvento.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public List<Evento> obterEventosAtividade(Aluno obj) {
        return apl.obterEventosAtividade(obj);
        
    }

    public List<TipoEvento> obterTipoEventos() {
        try {
            return apl.obterTipoEventos();
        } catch (Exception ex) {
            Logger.getLogger(CtrlEvento.class.getName()).log(Level.SEVERE, null, ex);
            return null;
        }
    }
}
